#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stats.h>
#include <string>
#include <fnct1.h>

#define COMMAND_SIZE 1024 
#define FORMAT "[%s@%s %s]# "

// 1.命令行参数表
#define MAXARGC 128
char* g_argv[MAXARGC];
int g_argc;

// 2.环境变量表
#define MAX_ENVS 100
char *g_env[MAX_ENV];
int g_envs = 0;

// 3.别名映射表
std::unordered_map<std::string, std::string> alias_list;

// 4.关于重定向
#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3

int redir = NONE_REDIR;
std::string filename;

// 当前路径
char cwd[1024];
char cwdenv[1024];

// 退出码
int lastcode = 0;

// 用户名
const char* GetUserName()
{
	const char* name = getenv("USER");
	return name == NULL ? "None" : name;
}

// 主机名
const char* GetHostName()
{
	const char* hostname = getenv("HOSTNAME");
	return hostname == NULL ? "None" : hostname;
}

// “HOME”
const char* GetHome()
{
	const char* home = getenv("HOME"); 
	return home == NULL ? "" : home;
}

// 对当前路径进行处理
std::string DirName(const char* pwd)
{
#define SLASH "/"
	std::string dir = pwd;
	if(dir == SLASH) return "/";
	auto pos = dir.rfind(SLASH);
	if(pos == std::string::npos) return "BUG";
	return dir.substr(pos + 1);
}

// PWD
const char* GetPwd()
{
	// cd 是内建命令，应该由父类执行。
	// 如果子类执行，退出子进程后，environ仍然是进入子进程之前的东西。（子进程深拷贝父进程的environ，所以子进程改变，父进程不会变）
	//const char* pwd = getenv("PWD");
	
	const char* pwd = getcwd(cwd, 1024);
	if(pwd != NULL)
	{
		snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
		putenv(cwdenv);
		return pwd;
	}	
	return pwd == NULL ? "None" : pwd;
}

void MakeCommandLine(char cmd_prompt[], int size)
{
	snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), DirName(GetPwd()).c_str());
}

// 输出命令行提示符
void PrintCommandPrompt()
{
	char prompt[COMMAND_SIZE];
	MakeCommandLine(prompt, sizeof(prompt));
	printf("%s", prompt);
	// 一定记得刷新缓冲区
	fflush(stdout);
}

// 获取user输入的命令，先通过对commandline进行格式化输入
bool GetCommandLine(char* out, int size)
{
	//fgets会以'\n'为终止符，并且自动加上'\0'，要注意的是，'\n'也会进入str中；
	char* c = fgets(out, size, stdin);
	if(c == NULL) return false;

	//对str的'\n'清理
	out[strlen(out) - 1] = 0;

	if(strlen(out) == 1) return false;
	// 如果用户输入的是’\n‘，那么，直接不执行即可
	return true;
}

// 对用户输入的命令，也就是commandline 进行分析
bool CommandParse(char* commandline)
{
// 空格作为界限
#define SEP " "
	g_argc = 0;
	g_argv[g_argc++] = strtok(commandline, SEP);
	while(g_argv[g_argc++] = strtok(NULL, SEP));
	g_argc--;
	return g_argc > 0 ? true : false;
}

// 打印命令行参数表
void PrintArgv()
{
    for(int i = 0; g_argv[i]; i++)
    {
        printf("argv[%d]->%s\n", i, g_argv[i]);
    }
    printf("argc: %d\n", g_argc);
}


void InitEnv()
{
    extern char **environ;
    memset(g_env, 0, sizeof(g_env));
    g_envs = 0;

    //本来要从配置文件来
    //1. 获取环境变量
    for(int i = 0; environ[i]; i++)
    {
        // 1.1 申请空间
        g_env[i] = (char*)malloc(strlen(environ[i])+1);
        strcpy(g_env[i], environ[i]);
        g_envs++;
    }
    g_env[g_envs++] = (char*)"HAHA=for_test"; //for_test
    g_env[g_envs] = NULL;

    //2. 导成环境变量
    for(int i = 0; g_env[i]; i++)
    {
        putenv(g_env[i]);
    }
    environ = g_env;
}
// 程序运行。
int Execute()
{
	// 创建子进程
	pid_t id = fork();
	if(id == 0)
	{
		int fd = -1;
		if(redir == INPUT_REDIR)
		{
			fd = open(filename.c_str(), O_RDONLY);
			if(fd < 0) exit(1);
			dup2(fd, 0);
			close(fd);
		}	
		else if(redir == OUTPUT_REDIR)
		{
			fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0666);
			if(fd < 0) exit(2);
			dup2(fd, 1);
			close(fd);
		}
		else if(redir == APPEND_REDIR)
		{
			fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_APPEND, 0666);
			if(fd < 0) exit(3);
			dup2(fd, 1);
			close(fd);
		}
		else {}
		// 进程替换，把子进程的代码和数据替换，转为执行shell中输入的命令
		// 使用命令行参数表查询
		execvp(g_argv[0], g_argv);
		exit(1);
	}

	// 父进程阻塞调用，等待子进程执行完
	int status = 0;// status获取退出信息
	pid_t rid = waitpid(id, &status, 0);
	if(rid > 0)
	{
		//更新退出码
		lastcode = WEXITSTATUS(status);
	}

	return 0;
}

// 内键命令cd的处理
bool cd()
{
	if(g_argc == 1) // 说明，输入命令cd，返回家目录
	{
		std::string home = GetHome();
		if(home.empty()) return true;
		chdir(home.c_str()); // 一个进程文件共用一个cwd，chdir改变进程文件中的cwd，再进行pwd命令就可以通过cwd显示
	}
	else
	{
		std::string where = g_argv[1];
		if(where == "-")
		{
		}
		else if(where == "~")
		{
		}
		else
		{
			chdir(where.c_str());
		}
	}

	return true;
}

// 内键命令echo的处理--------------------------------------------------------------------
bool echo()
{
	if(g_argc == 2)
	{
		//echo $?
		//echo $PATH
		//echo "hello world"
		std::string opt = g_argv[1];
		if(opt == "$?")
		{
			std::cout << lastcode << std::endl;
			lastcode = 0;
		}
		if(opt[0] == '$')
		{
			std::string env_name = opt.substr(1);
			const char* env_value = getenv(env_name.c_str());
			if(env_value)
				std::cout << env_value << std::endl;	
		}
	}
	return true;
}

// 内键命令的处理
bool CheckAndExecBuiltin()
{
	std::string cmd = g_argv[0];
	if(cmd == "cd")
	{
		cd();	
		return true;
	}
	else if(cmd == "echo")
	{
		echo();
		return true;
	}	
	return false;
}

// 重定向分析
void RedirCheck(char commandline[])
{

}

int main()
{
	InitEnv();
	// shell启动的时候，从系统中获取环境变量
	// 但是，我现在是从父类获取
	while(true)
	{
		// 1.输出cmd prompt
		PrintCommandPrompt();

		// 2.get user command
		char commandline[COMMAND_SIZE];
		if(!GetCommandLine(commandline, sizeof(commandline))) 
			continue;
		
		// 3.重定向分析	
		RedirCheck(commandline);

		// 4.parse command
		// commandline 存贮命令"ls -a -l"->"ls" "-a" "-l"
		if(!CommandParse(commandline)) 
			continue;
		// PrintArgv();
		
		// 5.check and exec builtin
		if(CheckAndExecBuiltin())
			continue;
		
		// 6.execute command
		Execute();
	}
	return 0;
}
